🧩 Part 1: Wrapper Classes in Java

🔷 What is a Wrapper Class?

A Wrapper class is a class whose object wraps a primitive data type. Java provides these classes in the java.lang package to convert primitive types into objects.

🧱 Primitive Types vs Wrapper Classes

Primitive Type Wrapper Class
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

🔍 Why Wrapper Classes are Needed?

Key Reasons:

  • Collections API: Like ArrayList, HashMap can only store objects (not primitives)
  • Utilities: Wrapper classes have methods like parseInt(), compare(), valueOf()
  • Autoboxing/Unboxing: Java automatically converts between primitives and wrappers
  • Can be null: Useful when working with databases where a value may be unknown
  • Generic Support: Generics in Java (like <T>) do not support primitives, only objects

🔁 Autoboxing and Unboxing

Autoboxing = primitive ➡️ object

Unboxing = object ➡️ primitive

public class AutoBoxingExample {
    public static void main(String[] args) {
        int a = 10;

        // Autoboxing
        Integer obj = a;

        // Unboxing
        int b = obj;

        System.out.println("Object: " + obj);
        System.out.println("Primitive: " + b);
    }
}

💼 Real-Life Example

Let's say you want to store user ages in a list:

ArrayList<Integer> ages = new ArrayList<>();
ages.add(25); // Autoboxing happens here: int ➝ Integer
ages.add(30);

int sum = ages.get(0) + ages.get(1); // Unboxing: Integer ➝ int
System.out.println("Sum of ages: " + sum);

🛠️ Useful Wrapper Class Methods

public class WrapperMethods {
    public static void main(String[] args) {
        String number = "100";

        int value = Integer.parseInt(number); // Convert string to int
        System.out.println("Parsed value: " + value);

        String text = Integer.toString(1234); // Convert int to string
        System.out.println("String value: " + text);

        boolean result = Boolean.parseBoolean("true");
        System.out.println("Boolean value: " + result);

        char ch = 'A';
        System.out.println("Is Digit: " + Character.isDigit(ch));
        System.out.println("Is Uppercase: " + Character.isUpperCase(ch));
    }
}

📌 Interview Point of View (Wrapper Class)

🔹 Question 💬 Expected Answer
What is a wrapper class? A class that converts a primitive type into an object.
Why are wrapper classes needed? For collections, generics, null handling, utilities.
Difference between Integer and int? int is primitive, Integer is a class (object).
What is autoboxing/unboxing? Auto conversion between primitive and wrapper.
Can you store int in ArrayList? Not directly — it uses Integer via autoboxing.

📘 Generics in Java

🔹 What is Generics?

Generics allows writing code that works with different data types while providing type safety.

Introduced in: Java 5

🔹 Why Use Generics?

  • ✅ Type safety
  • ✅ Reusability
  • ✅ Compile-time checking
  • ✅ No need for type casting

🔹 Generic Class Example

class Box<T> {
    T value;
    void setValue(T val) { value = val; }
    T getValue() { return value; }
}

🔹 Using Generic Class

Box<String> s = new Box<>();
s.setValue("Hi");
System.out.println(s.getValue());

🔹 Generic Method

public <T> void print(T[] arr) {
    for (T t : arr)
        System.out.println(t);
}

🔹 Bounded Type

class Demo<T extends Number> {
    void show(T n) {
        System.out.println(n.doubleValue());
    }
}

🔹 Wildcards

  • <?> – unknown type
  • <? extends Number> – any subclass of Number
  • <? super Integer> – any superclass of Integer

✅ Summary

  • Generic = Type-safe reusable code
  • Used in collections, utilities, containers
  • Makes code more readable and safer
💡 Part 2: Why Java is Not Fully Object-Oriented

❓ What is a Fully Object-Oriented Language?

A fully object-oriented language is one where:

Examples: Smalltalk, Ruby, Scala

❌ Why Java is Not 100% Object-Oriented?

Reason Explanation
Primitive Types Java has int, float, char, etc., which are not objects.
Static Methods/Variables Methods like Math.sqrt() don't need objects.
Limited Operator Overloading Custom operator overloading is not allowed.
Top-Level Code Outside Objects Static context used before object creation (e.g., main method).

📘 Real-World Analogy

🔧 Toolkit Analogy

Think of a programming language like a toolkit.

In Java, sometimes it uses tools outside the object world (like int instead of Integer), which breaks the pure object-oriented rule.

Whereas in Smalltalk:

3 + 4   "Even 3 is an object, and + is a message"

🔄 Comparison: Java vs Pure OOP

🟡 Java (Hybrid)

  • Has primitive types
  • Static methods exist
  • Performance optimized
  • Easier to learn

🟢 Pure OOP (Smalltalk)

  • Everything is an object
  • All operations via messages
  • Consistent design
  • More complex

📌 Interview Point of View (Object-Oriented)

🔹 Question 💬 Expected Answer
Is Java fully object-oriented? No, because it uses primitive types and static members.
Why does Java have primitives? For performance – primitives are faster and use less memory.
What makes Java object-oriented? Class-based, supports encapsulation, inheritance, polymorphism, and abstraction.
What breaks pure OOP in Java? int, boolean, static methods/fields, etc.

🧾 Final Summary

✅ Wrapper Class Summary

✅ Java Is Not Fully OOP Because:

🧠 Quick Revision for Interviews